﻿using System;

namespace Csharp类学习2021._10._25
{
    //class Person
    //{
    //    public int age;//非静态---通过对象名去调用 实例对象去调用 只能通过p调用

    //    public static int num;//静态成员，只能通过person调用

    //    public void Test(int age)
    //    {
    //        Console.WriteLine(this.age);//this关键字的作用代替实例对象
    //    }

    }
    //定义一个学生类
    class Student 
    {
        //学生基本属性
        public string name;
        public string sex;
        public int age;
        public int Csharp;
        public int Unity;


        //写一个构造函数
        public Student() { }//什么都不写，就是默认构造函数

        public Student(string name) 
        {
            this.name = name;//指向自身对象
        }
    public Student(string name, string sex) : this(name) 
    {
        this.sex = sex;
    }

    //写一个重载的构造函数(带参构造函数) 写法1
    //public Student(string name,string sex,int age,int Csharp,int Unity) //传入了一个string 参数
    //{
    //    //这个name就是给基本属性的name赋值
    //    this.name=name;//要用关键字this，不然要报错
    //    this.sex = sex;
    //    this.age = age;
    //    this.Csharp = Csharp;
    //    this.Unity = Unity;
    //    Console.WriteLine("这里是指定的构造函数");


    //}

    //写法2
    public Student(string name, string sex, int age, int Csharp, int Unity):this(name,sex)
    {
        //这个name就是给基本属性的name赋值
        //要用关键字this，不然要报错
        //this.sex = sex;
        //this.age = age;
        //this.Csharp = Csharp;
        //this.Unity = Unity;
        Console.WriteLine("这里是带参的构造函数");


    }









    //方法----建议写两个方法
    public void Test()
        {
            int sum = Csharp + Unity;
            int avg = sum / 2;
            Console.WriteLine("我叫{0}，今年{1}岁，是{2}同学",this.name,this.age,this.sex,sum,avg);
        }
        public void ShowScore()//计算自己的事情，所以不需要参数，从自己身上拿
        {
            float sum = Csharp + Unity;
            float avg = sum / 2;
            Console.WriteLine("我的总分为{0},我的平均成绩为{1}",sum,avg);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region 封装 多态 继承

            //同一种指令，不同的行为

            //把相同属性和相同方法的对象，抽象出共同属性行为的模板叫做类

            //就是模板，我们通过这个模板，可以构建相应的对象
            //属性就是在程序中通过字段（所有数据类型的变量）和属性（C#的特性）来描述事物的特征
            //行为：在程序中通过方法（函数）来描述事物的行为

            /*
             * 类的声明
             *       访问修饰符class类名
             *       {
             *            字段；
             *            属性；
             *            方法；
             *       }
             *       
             * 我们尽可能将类定义在另一个类里面
             * 类也是一个复杂数据类型，也是需要我们先定义后使用
             * 
             * 类名 对象名（变量名）= new 类名();
             * 和结构体很相似，结构体对象是值类型
             * 
             * 类对象是引用类型
             * 
             * 类的实例化 在类声明是，this代表当前这个对象 this可以指向自己的实例
             * 
             * 初始化：
             * 
             *      对类对象成员进行赋值，在实例化后，应该对其对象初始化
             *      
             * 
             */
            #endregion

            //Person p = new Person();//非静态都要先实例化

            //p.age = 12;//注意区别

            //Person.num = 20;//注意区别

            #region 定义一个学生类
            //定义一个学生类，有五种属性，分别为姓名、姓名、性别，年龄，Csharp成绩，Unity成绩
            //有两个方法：

            //一个打招呼：介绍自己叫XX,今年几岁了，是男同学还是女同学

            //计算自己总分数和平均分方法显示

            //测试话效果：
            //实例化两个对象并测试：
            //张三 男 20岁 80 85
            //李四 女 19岁 85 90

            //创造张三就叫实例化 数值给他就叫赋值化
            Student zhangsan = new Student("张三","男",20,80,85);
            //zhangsan.name = "张三";
            //zhangsan.sex = "男";
            //zhangsan.age = 20;
            //zhangsan.Csharp = 80;
            //zhangsan.Unity = 85;
            zhangsan.Test();
            zhangsan.ShowScore();

            Student lisi = new Student("李四","女",19,85,90);
            //lisi.name = "李四";
            //lisi.sex = "女";
            //lisi.age = 19;
            //lisi.Csharp = 85;
            //lisi.Unity = 90;
            lisi.Test();
            lisi.ShowScore();


            //对象是类的实例，它具有具体的属性和行为，对象不能索引到静态方法
            //对象的生命周期
            /*
             * 构造——————使用———————析构
             * 
             * 什么是构造函数
             *      当一个类被实例化为一个对象时，将会调用构造函数完成时对象的初始化
             *      类person的构造函数为person();
             *      
             * 构造函数声明：
             * 访问修饰符 类名(参数)
             * {
             *    初始化
             * }
             * 
             * 没有返回值，不能写id名
             * 方法名必须和类名一致
             * 不指定时，将有一个默认构造
             * 指定时，默认构造将失效---但可以重载出默认构造
             * 
             * 构造函数重载
             * 我们可以给一个类指定多个构造函数
             * 构造函数的重载使我们在声明对象能更加灵活
             * 
             * 类Person的构造函数为Person("name")----》把name作为参数传进去了
             * 
             * 没有返回类型，因为固定返回对应的对象
             * 构造函数的方法名必须与类名一致
             * 
             * 
             * this 作用
             * 1.指代自身的实例对象
             * 2.用来指向对象的构造函数
             * 
             * 
             * 不要在构造函数里面再去写构造
             */
            #endregion






        }
    }

   

}
